<?xml version="1.0" encoding="UTF-8"?>
<html>
    <head>
        <link type="text/css" rel="stylesheet" href="./css/template.css" />
        <link type="text/css" rel="stylesheet" href="./css/SyntaxHighlighter.css" />
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Connexion socket sécurisée en Java</title>
        <script language="javascript" src="./js/shInit.js" />
        <script language="javascript" src="./js/shCore.js" />
        <script language="javascript" src="./js/shBrushCpp.js" />
        <script language="javascript" src="./js/shBrushCSharp.js" />
        <script language="javascript" src="./js/shBrushCss.js" />
        <script language="javascript" src="./js/shBrushDelphi.js" />
        <script language="javascript" src="./js/shBrushJava.js" />
        <script language="javascript" src="./js/shBrushJScript.js" />
        <script language="javascript" src="./js/shBrushPhp.js" />
        <script language="javascript" src="./js/shBrushPython.js" />
        <script language="javascript" src="./js/shBrushRuby.js" />
        <script language="javascript" src="./js/shBrushSql.js" />
        <script language="javascript" src="./js/shBrushVb.js" />
        <script language="javascript" src="./js/shBrushXml.js" />
    </head>
    <body>
        <div class="chapter">
            <h2>Introduction</h2>
            <br />
            <p>En se connectant sur Internet, des liens généralement sans protection sont établis entre votre ordinateur et
				d'autres machines. Pour minimiser les risques de sécurité informatique liés à ces échanges de données, il est possible de sécuriser les connexions, lors de l'implémentation des programmes qui les utilisent.
				Nous allons donc voir comment mettre en place une connexion sécurisée entre un client et un serveur à l'aide
				de TLS (SSL v.3) en Java.</p>
        </div>
        <div class="chapter">
            <h2>1. Principes</h2>
            <div class="subChapter">
                <h3>1.1. SSL</h3>
                <p>
                    Le protocole Secure Socket Layer a été développé par Netscape en 1994 puis a été repris par l' IETF en 2001.
					Il porte la dénomination TLS pour Transport Layer Security depuis la version 3 du SSL.
					Ce protocole permet des échanges de données sécurisées grâce à des algorithme tel que RSA, et a pour objectif
					d'assurer l'authentification, la confidentialité et l'intégrité des données échangées mais aussi l'interopérabilité.
					SSL est composé d' un générateur de clés, de fonctions de hachage et d'algorithme de chiffrement ( RC4, MD5, SHA-1,
					DSS), de protocole de gestion de session (handshake protocol) et de certificats X509.
                    <br />
                    SSL fonctionne de manière simpliste comme ceci : Le serveur et le client s'échange des données pour utiliser les
					algorithme que le client peut supporter. Ensuite, c'est l'échange de clés publiques, le serveur envoie un certificat
					au client qui contient sa clé publique, le client génère une clé publique de session chiffrée avec le certificat du serveur.
					Une communication chiffrée par une clé de session identique sur le client et le serveur peut alors se dérouler durant
					toute la session.
                </p>
            </div>
            <div class="subChapter">
                <h3>1.2. JSSE</h3>
                <p>Cette extension est une implémentation des protocoles SSL et TLS destinée aux applications Java.
					JSSE étend les API de sécurité et réseau en fournissant une classe de sockets spécialisée SSL, des
					gestionnaires de clés, des système de fabriques de sockets mais aussi le support pour les mécanismes de
					négociation, d'authentification et de session. JSSE implémente RSA jusqu'à 2048 bits. JSSE était autrefois
					une extension mais est maintenant inclus dans le JDK 1.4.</p>
            </div>
        </div>
        <div class="chapter">
            <h2>2. Application</h2>
            <div class="subChapter">
                <h3>2.1. Création des certificats</h3>
                <ul>
                    <li>
                        <p>Création des deux certificats client et serveur dans les magasins de clés :</p>
                    </li>
                    <br />
                    Lancer l'invite de commande et tapez :
                    <br />
                    keytool -genkey -alias Client -keyalg RSA -keystore client_keystore -dname "cn=Client"
					-keypass password -storepass password
                    <p>
                        Puis ceci:
                        <br />
                        keytool -genkey -alias Server -keyalg RSA -keystore server_keystore -dname "cn=Server"
						-keypass password -storepass password
                    </p>
                    <p>
                        Maintenant que les certificats sont créés, vous pouvez les afficher :
                        <br />
                        keytool -list -keystore client_keystore
                    </p>
                    <p>
                        Au format RFC 1421 :
                        <br />
                        keytool -export -keystore client_keystore -alias Client -storepass password -rfc
                    </p>
                </ul>
                <ul>
                    <li>
                        <p>Signature fictive des certificats :</p>
                    </li>
                    <br />
                    Le certificat client :
                    <br />
                    keytool -selfcert -alias Client -keystore client_keystore -keypass password -storepass
					password
                    <p>
                        Et serveur :
                        <br />
                        keytool -selfcert -alias Server -keystore server_keystore -keypass password -storepass
						password
                    </p>
                </ul>
                <ul>
                    <p />
                    <li>Une fois les certificats signés, il faut exporter les clés publiques au format binaire dans un fichier :
						La clé publique du client :</li>
                    <br />
                    keytool -export -keystore client_keystore -alias Client -storepass password -file client_cert
                    <p>
                        Et la clé publique du serveur:
                        <br />
                        keytool -export -keystore server_keystore -alias Server -storepass password -file server_cert
                    </p>
                    <p>
                        Vous pouvez visualiser le contenu de ces fichiers:
                        <br />
                        keytool -printcert -file client_cert
                        <br />
                        keytool -printcert -file server_cert
                    </p>
                </ul>
                <ul>
                    <li>
                        <p>Importation des clés publiques dans le magasin de clé de l'autre partie</p>
                    </li>
                    <br />
                    keytool -import -alias Client -file client_cert -keystore server_keystore -storepass password
                    <br />
                    keytool -import -alias Server -file server_cert -keystore client_keystore -storepass password
                    <p />
                    <p>
                        Puis affichage du contenu des magasins de clés:
                        <br />
                        keytool -list -keystore server_keystore
                        <br />
                        keytool -list -keystore client_keystore
                    </p>
                </ul>
            </div>
            <div class="subChapter">
                <h3>2.2. Implémentation en java</h3>
                <p>Voici un exemple de serveur implémentant une connexion SSL : il accepte les connexions clientes et reçoit ce que
					tape le client en ligne de commande:</p>
                <br />
                <textarea name="code" class="java" rows="50" cols="50">import java.io.*;
					import javax.net.ssl.*;
					import java.security.KeyStore; //necessaire pour la gestion des magasins de clé
					class Serveur {
					public static final int PORT = 15000;
					public static final String HOST = "127.0.0.1";
					public static final String KEYSTORE_FILE = "server_keystore";
					public static final String ALGORITHM = "sunx509";
					public static final String PASSWORD = "password";
					public static void main(String[] args) {
					try {
					SSLServerSocket ecoute = null;
					KeyManagerFactory kmf;
					KeyManager[] km;
					KeyStore ks;
					TrustManagerFactory tmf;
					TrustManager[] tm;
					SSLContext sslc;
					ks = KeyStore.getInstance("JKS");
					ks.load(new FileInputStream(KEYSTORE_FILE), PASSWORD.toCharArray());
					kmf = KeyManagerFactory.getInstance(ALGORITHM);
					kmf.init(ks, PASSWORD.toCharArray());
					km = kmf.getKeyManagers();
					tmf = TrustManagerFactory.getInstance(ALGORITHM);
					tmf.init(ks);
					tm = tmf.getTrustManagers();
					sslc = SSLContext.getInstance("TLS");
					sslc.init(km, tm, null);
					SSLServerSocketFactory ssf = sslc.getServerSocketFactory();
					ecoute = (SSLServerSocket) ssf.createServerSocket(PORT);
					SSLSocket c = (SSLSocket) ecoute.accept();
					BufferedReader entree = new BufferedReader(new InputStreamReader(c.getInputStream()));
					while (true) {
					try {
					System.out.println(entree.readLine());
					} catch (IOException e) {
					System.out.println("Erreur " + e);
					}
					}
					} catch (Exception e) {
					System.out.println(e);
					}
					}
					}</textarea>
                <p>Le client :</p>
                <textarea name="code" class="java" rows="50" cols="50">import java.io.*;
					import javax.net.ssl.*;
					import java.security.KeyStore;
					class Client {
					public static final int PORT = 15000;
					public static final String HOST = "127.0.0.1";
					public static final String KEYSTORE_FILE = "client_keystore";
					public static final String ALGORITHM = "sunx509";
					public static final String PASSWORD = "password";
					public static void main(String[] args) {
					try {
					SSLSocket socket = null;
					KeyManagerFactory kmf;
					KeyStore ks;
					TrustManagerFactory tmf;
					SSLContext sslc;
					String line;
					kmf = KeyManagerFactory.getInstance(ALGORITHM);
					ks = KeyStore.getInstance("JKS");
					ks.load(new FileInputStream(KEYSTORE_FILE), PASSWORD.toCharArray());
					kmf.init(ks, PASSWORD.toCharArray());
					tmf = TrustManagerFactory.getInstance(ALGORITHM);
					tmf.init(ks);
					sslc = SSLContext.getInstance("TLS");
					sslc.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
					SSLSocketFactory sf = sslc.getSocketFactory();
					socket = (SSLSocket) sf.createSocket(HOST, PORT);
					System.out.println("Client connecte\n");
					PrintWriter sortie = new PrintWriter(socket.getOutputStream(), true);
					BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
					while (true) {
					try {
					line = br.readLine();
					sortie.println(line);
					sortie.flush();
					} catch (IOException e) {
					System.out.println("Erreur " + e);
					}
					}
					} catch (Exception e) {
					System.out.println(e);
					}
					}
					}</textarea>
                <p>Avant de démarrer l'application, il faut vérifier que les fichiers keystores et les
					clés publiques générées en ligne de commande plus haut sont bien au même niveau que
					l'application a lancé.</p>
                <p />
            </div>
        </div>
        <div class="chapter">
            <h2>3.Conclusion</h2>
            <p>JSSE est fournit en natif dans la version 1.4 du jdk de java, de plus, il utilise des algorithmes qui ont fait
				leurs preuves tels RSA ou DES. Cela dit, la sécurité offerte par SSL malgré qu' elle présente une avancée dans la
				protection des données et leur échange, reste relative et non suffisante dans une offre complète de sécurité.</p>
        </div>
    </body>
</html>

